home *** CD-ROM | disk | FTP | other *** search
/ HPAVC / HPAVC CD-ROM.iso / pc / ARASAN_S.ZIP / BOOK.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-06  |  3.4 KB  |  138 lines
  1. // Copyright 1992-3 by Jon Dart.  All Rights Reserved.
  2.  
  3. #include "book.h"
  4. #include "movegen.h"
  5. #include "moveord.h"
  6. #include "util.h"
  7. extern "C"
  8. {
  9. #include <stdlib.h>
  10. #include <time.h>
  11. };
  12.  
  13. Book::Book()
  14. {
  15.     time_t t;
  16.     srand((unsigned)time(&t));
  17.     bookw = new Book_Reader("BOOKW");
  18.     bookb = new Book_Reader("BOOKB");
  19. }    
  20.  
  21. Book::~Book()
  22. {
  23.     delete bookb;
  24.     delete bookw;
  25. }
  26.  
  27. Move Book::pick( const Board &b, uint16 node_index,
  28.    const Book_Entry &node )
  29. {
  30.      Book_Reader *reader = (b.Side() == White) ? bookw : bookb;
  31.      unsigned total_weight = 0;
  32.      unsigned indx = node_index;
  33.      while (indx != INVALID)
  34.      {
  35.         Book_Entry be;
  36.     reader->Fetch(indx, be);
  37.     if (be == node)
  38.            total_weight += be.recommend;
  39.         indx = be.next;
  40.      }
  41.      if (total_weight == 0)
  42.         return Move::NullMove();
  43.      unsigned weight = 0;
  44.      indx = node_index;
  45.      while (indx != INVALID)
  46.      {
  47.         Book_Entry be;
  48.     reader->Fetch(indx,be);
  49.     if (be == node && be.recommend > 0)
  50.     {
  51.            weight += be.recommend;
  52.        if ((rand()*(unsigned long)total_weight)/RAND_MAX < weight)
  53. //           if (random(total_weight) < weight )
  54.        {
  55.            Move moves[Move_Generator::MaxMoves];
  56.            Move_Generator mg( b, 0, Move::NullMove() );
  57.            int n = mg.Generate_Moves(moves,False,True); 
  58.            assert(be.move_index < n);
  59.             return moves[be.move_index];
  60.            }
  61.         }
  62.         indx = be.next;
  63.      }
  64.      // should never get here
  65.      assert(False);
  66.      return Move::NullMove();
  67. }
  68.  
  69. Move Book::book_move( const Board &b )
  70. {
  71.      Book_Reader *reader = (b.Side() == White) ? bookw : bookb;
  72.      if (!reader->Is_Open())
  73.          return Move::NullMove();
  74.  
  75.      unsigned indx = reader->Head(b);
  76.      Book_Entry target(b.HashCode(),0,0,0);
  77.      while (indx != INVALID)
  78.      {
  79.         Book_Entry be;
  80.         reader->Fetch(indx,be);
  81.         if (target == be)
  82.         return pick(b, indx, be);
  83.     else
  84.         indx = be.next;
  85.     }
  86.     return Move::NullMove();
  87. }
  88.  
  89. unsigned Book::book_moves( const Board &b, Move *moves, 
  90.     const unsigned limit)
  91. {
  92.      Book_Reader *reader = (b.Side() == White) ? bookw : bookb;
  93.      if (!reader->Is_Open())
  94.          return 0;
  95.  
  96.      unsigned indx = reader->Head(b);
  97.      Book_Entry target(b.HashCode(),0,0,0);
  98.      int num_moves = 0;
  99.      while (indx != INVALID)
  100.      {
  101.         Book_Entry be;
  102.         reader->Fetch(indx,be);
  103.         if ((target == be) && be.recommend)
  104.         num_moves++;
  105.         indx = be.next;
  106.     }
  107.     if (num_moves == 0)
  108.         return 0;
  109.     Move *tmp_moves = new Move[Move_Generator::MaxMoves];
  110.     Move_Generator mg( b, 0, Move::NullMove() );
  111.     int n = mg.Generate_Moves(tmp_moves,False,True); 
  112.     int * scores = new int[num_moves];
  113.     Move * tmp_moves2 = new Move[num_moves];
  114.     indx = reader->Head(b);
  115.     num_moves = 0;
  116.     while (indx != INVALID)
  117.     {
  118.         Book_Entry be;
  119.         reader->Fetch(indx,be);
  120.         if (target == be && be.recommend)
  121.     {
  122.        assert(be.move_index < n);
  123.            tmp_moves2[num_moves] = tmp_moves[be.move_index];
  124.        scores[num_moves] = be.recommend;
  125.        ++num_moves;
  126.     }
  127.         indx = be.next;
  128.     }
  129.     Move_Ordering::sort_moves(tmp_moves2,scores,num_moves);
  130.     unsigned ret_val = Util::Min(num_moves,limit);
  131.     for (int i = 0; i < ret_val; i++)
  132.        moves[i] = tmp_moves2[i];
  133.     delete [] scores;
  134.     delete [] tmp_moves;
  135.     delete [] tmp_moves2;
  136.     return ret_val;
  137. }
  138.